const lunisolar = require("../../单文件依赖/lunisolar_2.6.0.js");
const zhCn = require("../../单文件依赖/lunisolar_2.6.0-zh-cn.js");
const { theGods } = require("../../单文件依赖/thegods_0.1.4.min.js");
const fn北京时间 = require("../../单文件依赖/firfe_北京时间.js");
const fn时差天 = require("../../单文件依赖/firfe_时差天.js");

lunisolar.locale(zhCn);
lunisolar.extend(theGods);

const _节气列表 = lunisolar.SolarTerm.getNames();

let _当年节气日列表;

module.exports = function fn今日信息() {
  const _当前时间 = new Date();
  const _当前时间_北京 = fn北京时间(_当前时间);
  const _当前农历信息 = lunisolar(_当前时间_北京.字符串);

  const _当前节气 = _当前农历信息.solarTerm?.toString() ?? "无";

  const _当前宜 = _当前农历信息.theGods.getActs(0).good;
  const _当前忌 = _当前农历信息.theGods.getActs(0).bad;

  _当年节气日列表 = lunisolar.SolarTerm.getYearTermDayList(_当前时间_北京.年);

  const _节气前 = fn节气前(
    _当前时间_北京.年,
    _当前时间_北京.月,
    _当前时间_北京.日,
    _当前农历信息
  );

  const _节气后 = fn节气后(
    _当前时间_北京.年,
    _当前时间_北京.月,
    _当前时间_北京.日,
    _当前农历信息
  );

  return {
    公历: {
      年: _当前时间_北京.年,
      月: _当前时间_北京.月,
      日: _当前时间_北京.日,
    },
    gl: {
      n: _当前时间_北京.年,
      y: _当前时间_北京.月,
      r: _当前时间_北京.日,
    },
    星期: _当前时间_北京.星期,
    星期大写: fn数字转星期(_当前时间_北京.星期),
    xq: _当前时间_北京.星期,
    xqdx: fn数字转星期(_当前时间_北京.星期),
    日期: _当前时间_北京.日期,
    时间: _当前时间_北京.时间,
    rq: _当前时间_北京.日期,
    sj: _当前时间_北京.时间,
    农历: {
      年: _当前农历信息.format("lY年"),
      月: _当前农历信息.format("lM(lL)"),
      日: _当前农历信息.format("lD"),
      时: _当前农历信息.format("lH時"),
    },
    nl: {
      n: _当前农历信息.format("lY年"),
      y: _当前农历信息.format("lM(lL)"),
      r: _当前农历信息.format("lD"),
      s: _当前农历信息.format("lH時"),
    },
    季节: _当前农历信息.getSeason(),
    jj: _当前农历信息.getSeason(),
    天干地支: {
      年: _当前农历信息.char8.year.toString(),
      月: _当前农历信息.char8.month.toString(),
      日: _当前农历信息.char8.day.toString(),
      时: _当前农历信息.char8.hour.toString(),
    },
    tgdz: {
      n: _当前农历信息.char8.year.toString(),
      y: _当前农历信息.char8.month.toString(),
      r: _当前农历信息.char8.day.toString(),
      s: _当前农历信息.char8.hour.toString(),
    },
    节气: _当前节气,
    jq: _当前节气,
    节气前: _节气前.中文,
    jqq: _节气前.拼音,
    节气后: _节气后.中文,
    jqh: _节气后.拼音,
    宜5: fn随机打乱数组(_当前宜).slice(0, 5).join("，"),
    忌5: fn随机打乱数组(_当前忌).slice(0, 5).join("，"),
    宜: _当前宜.join("，"),
    忌: _当前忌.join("，"),
    y5: fn随机打乱数组(_当前宜).slice(0, 5).join("，"),
    j5: fn随机打乱数组(_当前忌).slice(0, 5).join("，"),
    y: _当前宜.join("，"),
    j: _当前忌.join("，"),
  };
};

function fn数字转星期(数字) {
  // 星期映射表，0为天，1-6为一到六
  const 星期映射 = ["天", "一", "二", "三", "四", "五", "六"];

  // 容错处理：确保输入为数字且在有效范围内
  const 数值 = Number(数字);

  // 如果不是有效数字，返回默认值
  if (isNaN(数值)) {
    return "天";
  }

  // 使用模运算处理超出范围的数字（如8返回一）
  const 索引 = ((数值 % 7) + 7) % 7;

  return 星期映射[索引];
}

function fn节气前(_年, _月, _日, _当前农历信息) {
  const _当前日期 = `${_年}-${_月}-${_日}`;

  let _前节气 = _当前农历信息.recentSolarTerm(2)[0].toString();
  const _前节气位置 = _节气列表.indexOf(_前节气);

  // 当前日期为节气，默认获取的前一个节气还是这一天，需要手动调整前一个节气
  if (_当前农历信息.solarTerm?.toString() ?? "无" != "无") {
    _前节气 = _节气列表[_前节气位置 - 1];
  }

  // 当前日期为节气小寒时，前一个节气为前一年是的冬至
  if (_前节气位置 == 0) {
    _前节气 = "冬至";
    _年 = _年 - 1;
  }

  let _前节气信息 = fu指定年节气日期(_年, _前节气);

  let _相差天数 = fn时差天(_当前日期, _前节气信息.日期);

  // 当前日期小于本年小寒，则前一个节气为上一年的节气，需要手动调整年份
  if (_相差天数 < 0) {
    _前节气信息 = fu指定年节气日期(_年 - 1, _前节气);
  }

  let _节气前 = {
    // 当前节气: _节气,
    // 当前日期: `${_年}-${_月}-${_日}`,
    节气: _前节气,
    节气日期: _前节气信息.日期,
    过去天数: fn时差天(_当前日期, _前节气信息.日期),
  };

  return {
    中文: _节气前,
    拼音: {
      jq: _节气前.节气,
      rq: _节气前.节气日期,
      ts: _节气前.过去天数,
    },
  };
}

function fn节气后(_年, _月, _日, _当前农历信息) {
  const _当前日期 = `${_年}-${_月}-${_日}`;
  // console.log(`fn节气后 调试 _当前日期: ${_当前日期}`);
  const _当前月第一个节气索引 = _月 * 2 - 2;
  const _当前月第一个节气日期 = _当年节气日列表[_当前月第一个节气索引];
  const _当前月第二个节气日期 = _当年节气日列表[_当前月第一个节气索引 + 1];
  // console.log(`fn节气后 调试 _当前月第一个节气日期: ${_当前月第一个节气日期}`);
  // console.log(`fn节气后 调试 _当前月第二个节气日期: ${_当前月第二个节气日期}`);

  let _后节气索引;

  if (_日 < _当前月第一个节气日期) {
    _后节气索引 = _当前月第一个节气索引;
  }
  if (_日 >= _当前月第一个节气日期) {
    _后节气索引 = _当前月第一个节气索引 + 1;
  }
  if (_日 >= _当前月第二个节气日期) {
    _后节气索引 = _当前月第一个节气索引 + 2;
  }
  // console.log(`fn节气后 调试 _后节气索引: ${_后节气索引}`);
  // console.log(`fn节气后 调试 _节气列表: 长度${_节气列表.length} 第24个元素 ${_节气列表[24]}`);

  if (_后节气索引 >= _节气列表.length) {
    _后节气索引 = 0;
    _年 = _年 + 1;
  }

  const _后节气 = _节气列表[_后节气索引];
  const _后节气信息 = fu指定年节气日期(_年, _后节气);

  let _节气后 = {
    // 当后节气: _节气,
    // 当后日期: `${_年}-${_月}-${_日}`,
    节气: _后节气,
    节气日期: _后节气信息.日期,
    距离天数: fn时差天(_后节气信息.日期, _当前日期),
  };

  return {
    中文: _节气后,
    拼音: {
      jq: _节气后.节气,
      rq: _节气后.节气日期,
      ts: _节气后.距离天数,
    },
  };
}

function fu指定年节气日期(年, 节气) {
  const _节气位置 = _节气列表.indexOf(节气);
  const _节气日 = _当年节气日列表[_节气位置];
  const _节气月 = Math.ceil((_节气位置 + 1) / 2);
  return {
    年: 年,
    月: _节气月,
    日: _节气日,
    节气: 节气,
    日期: `${年}-${_节气月}-${_节气日}`,
  };
}

function fn随机打乱数组(数组) {
  const _新数组 = [...数组];
  for (let i = _新数组.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [_新数组[i], _新数组[j]] = [_新数组[j], _新数组[i]];
  }
  return _新数组;
}
